home *** CD-ROM | disk | FTP | other *** search
/ Freelog 9 / Freelog009.iso / BAS / Internet / Rtf2Html / Source C / LIB / HTML.C < prev    next >
Encoding:
C/C++ Source or Header  |  1999-06-27  |  11.1 KB  |  618 lines
  1.  
  2. /*
  3.  * %%File: html.c
  4.  * 
  5.  * Copyright (c) 1995-1999 Bertrand LE QUELLEC
  6.  *
  7.  * http://perso.wanadoo.fr/blq
  8.  * blq@wanadoo.fr
  9.  */
  10.  
  11.  
  12. #include <stdio.h>
  13.  
  14. #include "lib.h"
  15.  
  16. #include "ansi_map.h"
  17. #include "ansi_mac.h"
  18. #include "html_map.h"
  19.  
  20. #define SOURCE_HTML     1
  21. #include "html.h"
  22.  
  23.  
  24. static char StringTmp[MLEN * 3];
  25.  
  26.  
  27. /*
  28.  * %%Function: TitreHTML
  29.  *
  30.  * Envoie sur le file pointeur un titre HTML.
  31.  */
  32. void TitreHTML(char * titre, FILE * out)
  33. {
  34.     FILE * sortie = (FILE *)0;
  35.  
  36.  
  37.     if(!(sortie = out))
  38. #ifdef UNIX_SRC
  39.         sortie = stdout;
  40. #else
  41.         return;
  42. #endif
  43.  
  44.     fprintf(sortie, "\n%s%s%s%s%s\n",
  45.         TAG_HEAD, TAG_TITLE, titre, TAGf_TITLE, TAGf_HEAD);
  46. }
  47.  
  48. /*
  49.  * %%Function: EnteteHTML
  50.  *
  51.  * Envoie sur le file pointeur une entete HTML par defaut.
  52.  */
  53. void EnteteHTML(char * tag, FILE * out)
  54. {
  55.     FILE * sortie = (FILE *)0;
  56.  
  57.  
  58.     if(!(sortie = out))
  59. #ifdef UNIX_SRC
  60.         sortie = stdout;
  61. #else
  62.         return;
  63. #endif
  64.  
  65.     fprintf(sortie, "\n%s\n%s\n%s%s\n",
  66.         TAG_DTD, TAG_HTML, TAG_BODY, tag);
  67. }
  68.  
  69. /*
  70.  * %%Function: BgColorHTML
  71.  */
  72. void BgColorHTML(char * couleur, FILE * out)
  73. {
  74.     FILE * sortie = (FILE *)0;
  75.  
  76.  
  77.     if(!(sortie = out))
  78. #ifdef UNIX_SRC
  79.         sortie = stdout;
  80. #else
  81.         return;
  82. #endif
  83.  
  84.     fprintf(sortie, "%s\"%s\"%s\n", TAG_BGCOLOR, couleur, TAGf);
  85. }
  86.  
  87. /*
  88.  * %%Function: BackgroundHTML
  89.  */
  90. void BackgroundHTML(char * image, FILE * out)
  91. {
  92.     FILE * sortie = (FILE *)0;
  93.  
  94.  
  95.     if(!(sortie = out))
  96. #ifdef UNIX_SRC
  97.         sortie = stdout;
  98. #else
  99.         return;
  100. #endif
  101.  
  102.     fprintf(sortie, "%s\n%s\"%s\"%s\n",
  103.         TAG_BODY, TAG_BACKGROUND, image, TAGf);
  104. }
  105.  
  106. /*
  107.  * %%Function: CelluleColHTML
  108.  *
  109.  * Envoie sur le file pointeur une cellule de tableau avec un
  110.  * positionnment sur le nombre de colone.
  111.  */
  112. void CelluleColHTML(char * cellule, FILE * out, int nbcol)
  113. {
  114.     FILE * sortie = (FILE *)0;
  115.  
  116.  
  117.     if(!(sortie = out))
  118. #ifdef UNIX_SRC
  119.         sortie = stdout;
  120. #else
  121.         return;
  122. #endif
  123.  
  124.     if(cellule)
  125.     {
  126.         fprintf(sortie, "%s%d%s\n%s\n%s\n",
  127.             TAG_TD_COLSPAN, nbcol, TAGf, cellule, TAGf_TD);
  128.     }
  129. }
  130.  
  131.  
  132. /*
  133.  * %%Function: CelluleHTML
  134.  *
  135.  * Envoie sur le file pointeur une cellule de tableau.
  136.  */
  137. void CelluleHTML(char * cellule, FILE * out)
  138. {
  139.     FILE * sortie = (FILE *)0;
  140.  
  141.  
  142.     if(!(sortie = out))
  143. #ifdef UNIX_SRC
  144.         sortie = stdout;
  145. #else
  146.         return;
  147. #endif
  148.  
  149.     if(cellule)
  150.     {
  151.         fprintf(sortie, "%s\n%s\n%s\n", TAG_TD, cellule, TAGf_TD);
  152.     }
  153. }
  154.  
  155. /*
  156.  * %%Function: CelluleCenterHTML
  157.  *
  158.  * Envoie sur le file pointeur une cellule centree de tableau.
  159.  */
  160. void CelluleCenterHTML(char * cellule, FILE * out)
  161. {
  162.     FILE * sortie = (FILE *)0;
  163.  
  164.  
  165.     if(!(sortie = out))
  166. #ifdef UNIX_SRC
  167.         sortie = stdout;
  168. #else
  169.         return;
  170. #endif
  171.  
  172.     if(cellule)
  173.     {
  174.         fprintf(sortie, "%s\n%s\n%s\n", TAG_TD_CENTER, cellule, TAGf_TD);
  175.     }
  176. }
  177.  
  178. /* -------------------------------------------------------------------------- */
  179.  
  180.  
  181. /*
  182.  * %%Function: GetFontSize
  183.  *
  184.  * renvoie un debut de FONT SIZE alloue.
  185.  */
  186. char * GetFontSize(int taille)
  187. {        
  188.     switch(taille)
  189.     {
  190.         case 0:
  191.         case 1:
  192.         case 2:
  193.             break;
  194.  
  195.         case 3:
  196.         case 4:
  197.             sprintf(StringTmp, "\n%s\n", TAG_FONT1);
  198.             return StringTmp;
  199.             break;
  200.  
  201.         case 5:
  202.         case 6:
  203.         case 7:
  204.         case 8:
  205.             sprintf(StringTmp, "\n%s\n", TAG_FONT2);
  206.             return StringTmp;
  207.             break;
  208.  
  209.         case 9:
  210.             sprintf(StringTmp, "\n%s\n", TAG_FONT3);
  211.             return StringTmp;
  212.             break;
  213.  
  214.         default:
  215.             break;
  216.     }
  217. }
  218.  
  219. /*
  220.  * %%Function: GetTableHTML
  221.  *
  222.  * renvoie un debut de tableau alloue.
  223.  */
  224. char * GetTableHTML(void)
  225. {        
  226.     sprintf(StringTmp, "\n%s\n", TAG_TABLE_BWIDTH);
  227.     return StringTmp;
  228. }
  229.  
  230. /*
  231.  * %%Function: GetImgSrcHTML
  232.  *
  233.  * Renvoie le code HTML correspondant a une reference image.
  234.  */
  235. char * GetImgSrcHTML(char * chaine)
  236. {          
  237.     if(chaine)
  238.     {                  
  239.         sprintf(StringTmp, "%s\"%s\">", TAG_IMG_SRC, chaine);
  240.         return StringTmp;
  241.     }
  242.  
  243.     return (char *)0;
  244. }
  245.  
  246. /*
  247.  * %%Function: GetANameHTML
  248.  *
  249.  * Renvoie le code HTML correspondant a une reference interne arrivee.
  250.  */
  251. char * GetANameHTML(char * chaine)
  252. {                    
  253.     if(chaine)
  254.     {
  255.         if (strlen(chaine) > 0)
  256.         {            
  257.             sprintf(StringTmp, "%s\"%s\">%s", TAG_ANAME, libDelQuote(chaine), chaine);
  258.             return StringTmp;
  259.         }
  260.     }
  261.  
  262.     return (char *)0;
  263. }
  264.  
  265. /*
  266.  * %%Function: GetANameHTML2
  267.  *
  268.  * Renvoie le code HTML correspondant a une reference interne arrivee.
  269.  */
  270. char * GetANameHTML2(char * chaine)
  271. {                    
  272.     if(chaine)
  273.     {  
  274.         if (strlen(chaine) > 0)
  275.         {          
  276.             sprintf(StringTmp, "%s\"%s\">", TAG_ANAME, libDelQuote(chaine));
  277.             return StringTmp;
  278.         }
  279.     }
  280.  
  281.     return (char *)0;
  282. }
  283.  
  284. /*
  285.  * %%Function: GetAHNameHTML
  286.  *
  287.  * Renvoie le code HTML correspondant a une reference depart pour NAME.
  288.  */
  289. char * GetAHNameHTML(char * chaine)
  290. {
  291.     if(chaine)
  292.     {
  293.         if (strlen(chaine) > 0)
  294.         {         
  295.             sprintf(StringTmp, "%s\"#%s\">%s%s", TAG_HREF, libDelQuote(chaine), chaine, TAGf_HREF);
  296.             return StringTmp;
  297.         }
  298.     }
  299.  
  300.     return (char *)0;
  301. }
  302.  
  303. /*
  304.  * %%Function: GetAHNameHTML2
  305.  *
  306.  * Renvoie le code HTML correspondant a une reference depart pour NAME.
  307.  */
  308. char * GetAHNameHTML2(char * dest, char * chaine)
  309. {
  310.     if(chaine)
  311.     {           
  312.         if (strlen(chaine) > 0)
  313.         { 
  314.             sprintf(StringTmp, "%s\"#%s\">%s%s", TAG_HREF, dest, chaine, TAGf_HREF);
  315.             return StringTmp;
  316.         }
  317.     }
  318.  
  319.     return (char *)0;
  320. }
  321.  
  322. /*
  323.  * %%Function: GetAHNameTargetHTML
  324.  *
  325.  * Renvoie le code HTML correspondant a une reference depart pour NAME dans une frame cible.
  326.  */
  327. char * GetAHNameTargetHTML(char * fichier, char * target, char * chaine)
  328. {
  329.     if(chaine)
  330.     {           
  331.         if (strlen(chaine) > 0)
  332.         { 
  333.             sprintf(StringTmp, "%s\"%s#%s\" TARGET=%s>%s%s", TAG_HREF, fichier, libDelQuote(chaine), target, chaine, TAGf_HREF);
  334.             return StringTmp;
  335.         }
  336.     }
  337.  
  338.     return (char *)0;
  339. }
  340.  
  341. /*
  342.  * %%Function: GetHrefHTML
  343.  *
  344.  * Renvoie le code HTML correspondant a une reference externe au fichier.
  345.  */
  346. char * GetHrefHTML(char * ref, char * chaine)
  347. {
  348.     if(chaine && ref)
  349.     {
  350.         if (strlen(chaine) > 0 && strlen(ref) > 0)
  351.         {            
  352.             sprintf(StringTmp, "%s\"%s\">%s%s", TAG_HREF, ref, chaine, TAGf_HREF);
  353.             return StringTmp;
  354.         }
  355.         else
  356.         {
  357.             if (strlen(chaine) > 0)
  358.             {
  359.                 sprintf(StringTmp, "%s", chaine);
  360.                 return StringTmp;
  361.             }
  362.         }
  363.     }
  364.  
  365.     return (char *)0;
  366. }
  367.  
  368. /*
  369.  * %%Function: GetHrefHTML2
  370.  *
  371.  * Renvoie le code HTML correspondant a une reference externe au fichier.
  372.  */
  373. char * GetHrefHTML2(char * ref, char * chaine)
  374. {
  375.     if(chaine && ref)
  376.     {
  377.         if (strlen(chaine) > 0 && strlen(ref) > 0)
  378.         {            
  379.             sprintf(StringTmp, "%s\"%s\" TARGET=_top>%s%s", TAG_HREF, ref, chaine, TAGf_HREF);
  380.             return StringTmp;
  381.         }
  382.         else
  383.         {
  384.             if (strlen(chaine) > 0)
  385.             {
  386.                 sprintf(StringTmp, "%s", chaine);
  387.                 return StringTmp;
  388.             }
  389.         }
  390.     }
  391.  
  392.     return (char *)0;
  393. }
  394.  
  395.  
  396. /*
  397.  * %%Function: GetNiveauHTML
  398.  *
  399.  * Renvoie le code HTML correspondant a un niveau.
  400.  */
  401. char * GetNiveauHTML(int niveau)
  402. {
  403.     switch(niveau)
  404.     {
  405.         case 0:
  406.         case 1:
  407.         case 41:
  408.             return TAG_H1;
  409.  
  410.         case 2:
  411.         case 42:
  412.             return TAG_H2;
  413.  
  414.         case 3:
  415.         case 43:
  416.             return TAG_H3;
  417.  
  418.         case 4:
  419.         case 44:
  420.             return TAG_H4;
  421.  
  422.         case 5:
  423.         case 45:
  424.             return TAG_H5;
  425.     }
  426.  
  427.     return (char *)0;
  428. }
  429.  
  430. /*
  431.  * %%Function: GetNiveauHTMLf
  432.  *
  433.  * Renvoie le code HTML (fermant) correspondant a un niveau.
  434.  */
  435. char * GetNiveauHTMLf(int niveau)
  436. {
  437.     switch(niveau)
  438.     {
  439.         case 0:
  440.         case 1:
  441.         case 41:
  442.             return TAGf_H1;
  443.  
  444.         case 2:
  445.         case 42:
  446.             return TAGf_H2;
  447.  
  448.         case 3:
  449.         case 43:
  450.             return TAGf_H3;
  451.  
  452.         case 4:
  453.         case 44:
  454.             return TAGf_H4;
  455.  
  456.         case 5:
  457.         case 45:
  458.             return TAGf_H5;
  459.     }
  460.  
  461.     return (char *)0;
  462. }
  463.  
  464.  
  465. /* -------------------------------------------------------------------------- */
  466.  
  467.  
  468. /*
  469.  * %%Function: TokenToHTML
  470.  *
  471.  * Renvoie le code HTML correspondant a un token.
  472.  */
  473. char * TokenToHTML(char * token)
  474. {
  475.     register int i = 0;
  476.  
  477.  
  478.     if(token)
  479.     {
  480.         while(tokenTag[i].token)
  481.         {
  482.             if(strcmp(tokenTag[i++].token, token) == 0)
  483.                 return tokenTag[--i].tagHTML;
  484.         }
  485.     }
  486.  
  487.     return (char *)0;
  488. }
  489.  
  490. /*
  491.  * %%Function: HTMLToToken
  492.  *
  493.  * Renvoie le token correspondant a un code HTML.
  494.  */
  495. char * HTMLToToken(char * html)
  496. {
  497.     register int i = 0;
  498.  
  499.  
  500.     if(html)
  501.     {
  502.         while(tokenTag[i].tagHTML)
  503.         {
  504.             if(strcmp(tokenTag[i++].tagHTML, html) == 0)
  505.                 return tokenTag[--i].token;
  506.         }
  507.     }
  508.  
  509.     return (char *)0;
  510. }
  511.  
  512.  
  513. /* ------------------------------------------------------------------------- */
  514.  
  515.  
  516. /*
  517.  * %%Function: HexaToToken
  518.  *
  519.  * Renvoie le token correspondant au code Hexa.
  520.  */
  521. char * HexaToToken(char * hexa)
  522. {
  523.     register int i = 0;
  524.  
  525.  
  526.     if(hexa)
  527.     {
  528.         while(ansiMapG[i].hexa)
  529.         {
  530.             if(strcmp(ansiMapG[i++].hexa, hexa) == 0)
  531.             {
  532.                 return ansiMapG[i-1].token;
  533.             }
  534.         }
  535.  
  536.         i = 0;
  537.  
  538.         while(ansiMacG[i].hexa)
  539.         {
  540.             if(strcmp(ansiMacG[i++].hexa, hexa) == 0)
  541.             {
  542.                 return ansiMacG[i-1].token;
  543.             }
  544.         }
  545.     }
  546.  
  547.     return (char *)0;
  548. }
  549.  
  550. /*
  551.  * %%Function: TokenToHexa
  552.  *
  553.  * Renvoie le code hexa correspondant au token.
  554.  */
  555. char * TokenToHexa(char * token)
  556. {
  557.     register int i = 0;
  558.  
  559.  
  560.     if(token)
  561.     {
  562.         while(ansiMapG[i].token)
  563.         {
  564.             if(strcmp(ansiMapG[i++].token, token) == 0)
  565.             {
  566.                 return ansiMapG[i-1].hexa;
  567.             }
  568.         }
  569.  
  570.         i = 0;
  571.  
  572.         while(ansiMacG[i].token)
  573.         {
  574.             if(strcmp(ansiMacG[i++].token, token) == 0)
  575.             {
  576.                 return ansiMacG[i-1].hexa;
  577.             }
  578.         }
  579.     }
  580.  
  581.     return (char *)0;
  582. }
  583.  
  584.  
  585. /* ------------------------------------------------------------------------- */
  586.  
  587.  
  588. /*
  589.  * %%Function: HTMLToHexa
  590.  *
  591.  * Renvoie le code hexa correspondant au code html.
  592.  */
  593. char * HTMLToHexa(char * html)
  594. {
  595.     if(html)
  596.     {
  597.         return TokenToHexa(HTMLToToken(html));
  598.     }
  599.  
  600.     return (char *)0;
  601. }
  602.  
  603. /*
  604.  * %%Function: HexaToHTML
  605.  *
  606.  * Renvoie le code html correspondant au code Hexa.
  607.  */
  608. char * HexaToHTML(char * hexa)
  609. {
  610.     if(hexa)
  611.     {
  612.         return TokenToHTML(HexaToToken(hexa));
  613.     }
  614.  
  615.     return (char *)0;
  616. }
  617.  
  618.